home *** CD-ROM | disk | FTP | other *** search
/ MacFormat España 14 / MacFormat n. 14 (Spain) / MacFormat 14.bin / C de cerca / Codewarrior Lite / MacOS Support / Headers / ANSI Headers / dynarray < prev    next >
Encoding:
Text File  |  1995-12-29  |  5.2 KB  |  194 lines
  1. // dynarray standard header
  2. #ifndef _DYNARRAY_
  3. #define _DYNARRAY_
  4. #include <exception>
  5.  
  6. #if __MWERKS__
  7. #pragma options align=mac68k
  8.  
  9. #if __CFM68K__ && __USING_IMPORTED_ANSI__
  10. #pragma import on
  11. #endif
  12. #endif
  13.  
  14.   // template class dynarray
  15. template<class _T> class dynarray {
  16. public:
  17.  dynarray()
  18.   {_Tidy(); }
  19.  dynarray(size_t _N, capacity _C)
  20.   {_Tidy(), _Res = _N;
  21.   if (_C == default_size)
  22.    _Grow(_N); }
  23.  dynarray(const dynarray<_T>& _X)
  24.   {_Tidy(), _Grow(_X.length());
  25.   for (size_t _I = 0; _I < _Len; ++_I)
  26.    _Ptr[_I] = (_T)_X[_I]; }
  27.  dynarray(const _T& _X, size_t _N = 1)
  28.   {_Tidy(), _Grow(_N, &_X); }
  29.  dynarray(const _T *_S, size_t _N)
  30.   {if (_S == 0)
  31.    _Xinv();
  32.   _Tidy(), assign(_S, _N); }
  33.  ~dynarray()
  34.   {_Tidy(1); }
  35.  dynarray<_T>& operator=(const dynarray<_T>& _R)
  36.   {return (this == &_R ? *this
  37.    : assign(_R.base(), _R.length())); }
  38.  dynarray<_T>& operator+=(const dynarray<_T>& _R)
  39.   {return (append(_R.base(), _R.length())); }
  40.  dynarray<_T>& operator+=(const _T& _R)
  41.   {return (append(_R)); }
  42.  dynarray<_T>& append(const _T& _X, size_t _N = 1)
  43.   {return (append(&_X, _N, 0)); }
  44.  dynarray<_T>& append(const _T *_S, size_t _N = 1,
  45.   size_t _D = 1)
  46.   {if (NPOS - _Len <= _N)
  47.    _Xlen();
  48.   size_t _I = _Len;
  49.   for (_Grow(_N += _I); _I < _N; ++_I, _S += _D)
  50.    _Ptr[_I] = (_T)*_S;
  51.   return (*this); }
  52.  dynarray<_T>& assign(const _T& _X, size_t _N = 1)
  53.   {return (assign(&_X, _N, 0)); }
  54.  dynarray<_T>& assign(const _T *_S, size_t _N = 1,
  55.   size_t _D = 1)
  56.   {_Grow(_N, 0, 1);
  57.   for (size_t _I = 0; _I < _N; ++_I, _S += _D)
  58.    _Ptr[_I] = (_T)*_S;
  59.   return (*this); }
  60.  dynarray<_T>& insert(size_t _P, const dynarray<_T>& _X)
  61.   {return (insert(_P, _X.base(), _X.length())); }
  62.  dynarray<_T>& insert(size_t _P, const _T& _X, size_t _N = 1)
  63.   {return (insert(_P, &_X, _N, 0)); }
  64.  dynarray<_T>& insert(size_t _P, const _T *_S, size_t _N = 1,
  65.   size_t _D = 1)
  66.   {if (_Len < _P)
  67.    _Xran();
  68.   if (NPOS - _Len <= _N)
  69.    _Xlen();
  70.   if (0 < _N)
  71.    {size_t _I = _Len - _P;
  72.    for (_Grow(_N + _Len); 0 < _I; )
  73.     --_I, _Ptr[_P + _N + _I] = _Ptr[_P + _I];
  74.    for (_I = 0; _I < _N; ++_I, _S += _D)
  75.     _Ptr[_P + _I] = (_T)*_S; }
  76.   return (*this); }
  77.  dynarray<_T>& remove(size_t _P = 0, size_t _N = NPOS)
  78.   {if (_Len < _P)
  79.    _Xran();
  80.   if (_Len - _P < _N)
  81.    _N = _Len - _P;
  82.   if (0 < _N)
  83.    {size_t _M = _Len - _P - _N;
  84.    for (size_t _I = 0; _I < _M; ++_I)
  85.     _Ptr[_P + _I] = _Ptr[_P + _I + _N];
  86.    _Grow(_Len - _N); }
  87.   return (*this); }
  88.  dynarray<_T>& sub_array(dynarray<_T>& _X, size_t _P,
  89.   size_t _N = NPOS)
  90.   {if (_Len < _P)
  91.    _Xran();
  92.   if (_Len - _P < _N)
  93.    _N = _Len - _P;
  94.   return (this == &_X ? (remove(_P + _N), remove(0, _P))
  95.    : _X.assign(&_Ptr[_P], _N)); }
  96.  void swap(dynarray<_T>& _X)
  97.   {_T *_Tp = _Ptr; _Ptr = _X._Ptr, _X._Ptr = _Tp;
  98.   size_t _Tl = _Len; _Len = _X._Len, _X._Len = _Tl;
  99.   size_t _Tr = _Res; _Res = _X._Res, _X._Res = _Tr; }
  100.  const _T& get_at(size_t _I) const
  101.   {if (_Len <= _I)
  102.    _Xran();
  103.   return (_Ptr[_I]); } 
  104.  void put_at(size_t _I, const _T& _X)
  105.   {if (_Len <= _I)
  106.    _Xran();
  107.   _Ptr[_I] = (_T)_X; } 
  108.  _T& operator[](size_t _I)
  109.   {return (_Ptr[_I]); } 
  110.  const _T& operator[](size_t _I) const
  111.   {return (_Ptr[_I]); } 
  112.  _T *base()
  113.   {return (_Len != 0 ? _Ptr : 0); }
  114.  const _T *base() const
  115.   {return (_Len != 0 ? _Ptr : 0); }
  116.  size_t length() const
  117.   {return (_Len); }
  118.  void resize(size_t _N)
  119.   {_Grow(_N, 0, 1); }
  120.  void resize(size_t _N, const _T& _X)
  121.   {_Grow(_N, &_X, 1); }
  122.  size_t reserve() const
  123.   {return (_Res); }
  124.  void reserve(size_t _R)
  125.   {if (_Ptr == 0)
  126.    _Res = _R; }
  127. private:
  128.  void _Grow(size_t _N, const _T *_S = 0, _Bool _Trim = 0)
  129.   {size_t _Os = _Ptr == 0 ? 0 : _Res;
  130.   if (_N == 0)
  131.    {if (_Trim)
  132.     _Tidy(1); }
  133.   else if (_N == _Os || _N < _Os && !_Trim)
  134.    { }
  135.   else if (_N == NPOS)
  136.    _Xlen();
  137.   else
  138.    {size_t _I, _M = _Ptr == 0 && _N < _Res ? _Res : _N;
  139.    _T *_Np = new _T[_M];
  140.    if (_Np == 0)
  141.     _Nomemory();
  142.    _Res = _M, _M = _N < _Len ? _N : _Len;
  143.    for (_I = 0; _I < _M; ++_I)
  144.     _Np[_I] = _Ptr[_I];
  145.    if (_S != 0)
  146.     for (; _I < _Res; ++_I)
  147.      _Np[_I] = (_T)*_S;
  148.    _Tidy(1), _Ptr = _Np; }
  149.   _Len = _N; }
  150.  void _Tidy(_Bool _Constructed = 0)
  151.   {if (_Constructed && _Ptr != 0)
  152.    delete[] _Ptr;
  153.   _Len = 0, _Ptr = 0, _Res = 0; }
  154.  void _Xinv() const
  155.   {invalidargument("invalid dynarray argument").raise(); }
  156.  void _Xlen() const
  157.   {lengtherror("dynarray too long").raise(); }
  158.  void _Xran() const
  159.   {outofrange("invalid dynarray position").raise(); }
  160.   _T *_Ptr;
  161.  size_t _Len, _Res;
  162.  };
  163.   // template operators
  164. template<class _T> dynarray<_T>
  165.  operator+(const dynarray<_T>& _L, const dynarray<_T>& _R)
  166.  {return (dynarray<_T>(_L) += _R); }
  167. template<class _T> dynarray<_T>
  168.  operator+(const dynarray<_T>& _L, const _T& _R)
  169.  {return (dynarray<_T>(_L) += _R); }
  170. template<class _T> dynarray<_T>
  171.  operator+(const _T& _L, const dynarray<_T>& _R)
  172.  {return (dynarray<_T>(_L) += _R); }
  173.  
  174. #if __MWERKS__
  175. #if __CFM68K__ && __USING_IMPORTED_ANSI__
  176. #pragma import reset
  177. #endif
  178.  
  179. #pragma options align=reset
  180. #endif
  181.  
  182. #endif
  183.  
  184. /*
  185.  * Copyright (c) 1994 by P.J. Plauger.  ALL RIGHTS RESERVED. 
  186.  * Consult your license regarding permissions and restrictions.
  187.  */
  188.  
  189. /* Change log:
  190.  *94Oct03 Version received from PlumHall
  191.  *94Oct07 Inserted MW changes.
  192.  *94Nov01mm Added explicit pointer casts of form (_T) in lines 22, 47, 55, 71, 103 and 143
  193.  */
  194.